#include <iostream>
using namespace std;

class Person {
public:
    Person(int num =10)
        :_num(num)
    {
        cout << "Person()构造函数" << endl;

    }
    //拷贝构造函数
    Person(const Person& p)
        :_num(p._num)
    {
        cout << " Person(const Person& p)" << endl;
    }
    //赋值构造函数
    Person operator=(const Person& p)
    {
        cout << "Person operator=(const Person& p)" << endl;
        if (this != &p)
        {
            _num = p._num;
        }
        return *this;
    }

    ~Person()
    {
        cout << "Person的析构函数" << endl;
        delete[] a;
    }
protected:
    int _num; //身份证号
    int* a = new int[10];
};

class Student :public Person {
public:
    Student()   //无参的构造函数
    {

    }
    Student(int num, int age)
        :Person(num)
        , _age(age)
    {
        cout << "Student(int num, int age)" << endl;
    }
    //拷贝构造
    Student(const Student& s)
        :Person(s)   //_num(s._num)  这里用到切片
        , _age(s._age)
    {
        cout << "Student()构造函数" << endl;
    }
    //赋值构造
    Student operator=(const Student& s)
    {
        cout << "Student operator=(const Student& s)" << endl;
        if (this != &s)
        {
            Person::operator=(s);  //父类的部分显示的调用父类的赋值构造
            _age = s._age;      
        }
        return *this;
    }

    ~Student()
    {
        //这就是编译器处理的问题，说到隐藏很类似，---编译器在处理之后，所有的类的析构函数她都会被重新命名称为deStructor()
        // 析构函数在对象的生命周期结束之后，他会自己调用的
        //1 、跟父类的析构函数构成隐藏关系
        //2、对象的生命周期结束之后，他会自己调用自己的析构函数
        //Person::~Person();   //不建议显示的调用父类的析构函数
        cout << "Student的析构函数" << endl;
    }
protected:
    int _age; //年龄
};

void Test()
{
    //Student s1;   //这里是age类型，不做处理，自定义类型调用自己的构造函数，父类调用父类的构造函数
    //Student s2(s1);
    Student s1(24, 30);  //调用子类的有参构造
    Student s2(s1);     //拷贝构造
    Student s3 = s1;   //赋值构造

}

int main()
{
    Test();
    return 0;
}

